import java.io.PrintStream;
import java.sql.SQLOutput;
//包装类只是针对基本数据类型的类类型
public class Test {
    public static void main(String[] args) {
        int a3 = 10;
        int b = 20;
        int max = a3 > b ? a3 : b ;
        System.out.println(max);
        System.out.println("===============================");



        int a2 = 10;
        int b2 = 20;
        int c2 = a2 + ( b - a2 ) >> 1;
        System.out.println(c2);
    }





    public static void main8(String[] args) {
        System.out.println(5/2);
        System.out.println((float)5 / 2);
        System.out.println(5 / (float)2);
        System.out.println((float)(5 / 2));
        System.out.println("===============================");
        System.out.println(10 % 3);//1
        System.out.println(10 % -3);//1
        System.out.println(-10 % 3);//-1
        System.out.println(-10 % -3);//-1
        System.out.println(11.5 % 2);//1.5


        int a = 10;
        a += 10;
        System.out.println(a);

        long d = 100;
        int c = 9;
        c += d;//c = (int )c + d 特点：运算符会帮我们进行类型转换
        System.out.println(c);


//        int a = 10;
//        //int b = ++a;//a = a+1;b = a
//        int b = a++;//b = a;a = a+1
//        System.out.println(a);
//        System.out.println(b);



//        int a = 10;
//        int b = 20;
//// 注意：在Java中 = 表示赋值，要与数学中的含义区分
//// 在Java中 == 表示相等
//        System.out.println(a == b); // false
//        System.out.println(a != b); // true
//        System.out.println(a < b); // true
//        System.out.println(a > b); // false
//        System.out.println(a <= b); // true
//        System.out.println(a >= b); // false



//        int a1 = 1;
//        int b = 2;
//        System.out.println(a1 == 1 && b == 2); // 左为真 且 右为真 则结果为真
//        System.out.println(a1 == 1 && b > 100); // 左为真 但 右为假 则结果为假
//        System.out.println(a1 > 100 && b == 2); // 左为假 但 右为真 则结果为假
//        System.out.println(a1 > 100 && b > 100); // 左为假 且 右为假 则结果为假



//        int a1 = 1;
//        int b = 2;
//        System.out.println(a1 == 1 || b == 2); // 左为真 且 右为真 则结果为真
//        System.out.println(a1 == 1 || b > 100); // 左为真 但 右为假 则结果也为真
//        System.out.println(a1 > 100 || b == 2); // 左为假 但 右为真 则结果也为真
//        System.out.println(a1 > 100 || b > 100); // 左为假 且 右为假 则结果为假



//        int a1 = 1;
//        System.out.println(!(a1 == 1));//false
//        System.out.println(!(a1 == 2));//true



        System.out.println(10 > 20 && 10 / 0 == 0); // 打印 false
        //当表达式1为假的时候，就不会执行表达式2了
        System.out.println(10 < 20 || 10 / 0 == 0); // 打印 true
        //当表达式1为真的时候，就不会执行表达式2了



        //这个不能表示短路【不建议这样写代码，这个是一个特殊的例子】
        System.out.println(10 > 20 & 10 / 0 == 0); // 程序抛出异常
        System.out.println(10 < 20 | 10 / 0 == 0); // 程序抛出异常
    }




        public static void main7(String[] args) {
        String str = "hello";
        String str2 = "world";
        //双引号当中包含若干个字符
        System.out.println(str);
        System.out.println(str + str2);


        int a = 100;
        String s1 = String.valueOf(a);
        //调用String这个类型的方法
        System.out.println(s1);

        String s2 = a + "hellox";
        System.out.println(s2);

        String s3 = a + "";
        //此时这个加号就是拼接的意思
        System.out.println(s3);

        String s4 = 10 + 20 + "x";
        String s5 = "x"+ 10 + 20 ;
        System.out.println(s4);
        System.out.println(s5);
        System.out.println("===============================");


        String str3 = "10009";
        int ret = Integer.valueOf(str3);
        System.out.println(ret + 1);

        int ret2 = Integer.parseInt(str3);
        System.out.println(ret2 + 1);
        //调用Integer的方法来实现转换

    }





    public static void main6(String[] args) {
        int a = 10;
        double b = 20;
        int c = (int)(a + b);
        //等号右边是long类型，左边是int类型，会造成数据精度丢失
        double d =  a + b;


        byte b1 = 125;
        byte b2 = 123;
        //小于四个字节的内容会被提升为int参与运算
        byte b3 = (byte)(b1 + b2);
        System.out.println(b3);

        int b4 = b1 + b2;
        System.out.println(b4);
    }





    public static void main5(String[] args) {
        int a = 10;
        double b =100L;
        //a = b;//不可以赋值8个给4个字节
        a = (int)b;//强制类型转换
        b = a ;//隐式类型转换

        //byte c1 = 256;
        byte c2 = 127;
        //java 当中对于字面值的直接赋值是允许的，前提是没有超过表示范围，当超过表示范围时，就会检查
    }
    public static void main4(String[] args) {
        boolean flg = true;
        //C语言中0是假，非0为真，但在java中，真假只有true和false
        //boolean类型不能和任何类型进行转换，并且没有明确规定Boolean占用几个字节
        System.out.println(flg);
    }





    public static void main3(String[] args) {
        //没有负数
        char ch = 'A';
        //2个字节，这个是和C有区别的；
        System.out.println(ch);
        char ch2 = '莫';
        System.out.println(ch2);
    }





    public static void main2(String[] args) {
        int a = 1;
        int b = 2;
        System.out.println(a / b);
        //从数学上来说 就是0.5；但是此时在程序上说不能够保存小数

        double num = 1.1;
        System.out.println(num * num);
        System.out.println("===============================");



        float f = 12.5f;
        System.out.println(f);
        //单精度的浮点类型 ：4个字节
        System.out.println(Float.MAX_VALUE);
        System.out.println(Float.MIN_VALUE);

    }





    public static void main1(String[] args) {
        int a = 1;
        System.out.println(a);
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
        System.out.println("===============================");



        System.out.println("hello");


       //长整型 8个字节 ：-2^63  - (2 ^63) -1
        long b = 10L;
        System.out.println(b);
        System.out.println(Long.MAX_VALUE);
        System.out.println(Long.MIN_VALUE);
        System.out.println("===============================");



        short sh = 10;
        //短整型 2个字节：-2 ^ 15  - (2 ^ 15) -1
        System.out.println(sh);
        System.out.println(Short.MAX_VALUE);
        System.out.println(Short.MIN_VALUE);
        System.out.println("===============================");



        byte b1 = 10;
        //字节型 1个字节：-2 ^ 7  - (2 ^ 7) -1
        System.out.println(b1);
        System.out.println(Byte.MAX_VALUE);
        System.out.println(Byte.MIN_VALUE);
        System.out.println("===============================");



        double d = 12.5;
        //双精度浮点型 8个字节：-2 ^ 63  - (2 ^ 63) -1
        System.out.println(d);
        System.out.println(Double.MAX_VALUE);
        System.out.println(Double.MIN_VALUE);
        System.out.println("===============================");

    }
}
